package com.exception;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/*
    在计算机程序运行的过程中，总是会出现各种各样的错误。
    有一些错误是用户造成的，比如，希望用户输入一个int类型的年龄，但是用户的输入是abc：
    程序想要读写某个文件的内容，但是用户已经把它删除了：
    还有一些错误是随机出现，并且永远不可能避免的。比如：
    网络突然断了，连接不到远程服务器；
    内存耗尽，程序崩溃了；
    用户点“打印”，但根本没有打印机；
    ……
    所以，一个健壮的程序必须处理各种各样的错误。
    所谓错误，就是程序调用某个函数的时候，如果失败了，就表示出错。
    调用方如何获知调用失败的信息？有两种方法：
    方法一：约定返回错误码。
    例如，处理一个文件，如果返回0，表示成功，返回其他整数，表示约定的错误码：
    因为使用int类型的错误码，想要处理就非常麻烦。这种方式常见于底层C函数。
    方法二：在语言层面上提供一个异常处理机制。
    Java内置了一套异常处理机制，总是使用异常来表示错误。
    异常是一种class，因此它本身带有类型信息。异常可以在任何地方抛出，但只需要在上层捕获，这样就和方法调用分离了：
    因为Java的异常是class，它的继承关系如下：

                         ┌───────────┐
                         │  Object   │
                         └───────────┘
                               ▲
                               │
                         ┌───────────┐
                         │ Throwable │
                         └───────────┘
                               ▲
                     ┌─────────┴─────────┐
                     │                   │
               ┌───────────┐       ┌───────────┐
               │   Error   │       │ Exception │
               └───────────┘       └───────────┘
                     ▲                   ▲
             ┌───────┘              ┌────┴──────────┐
             │                      │               │
    ┌─────────────────┐    ┌─────────────────┐┌───────────┐
    │OutOfMemoryError │... │RuntimeException ││IOException│...
    └─────────────────┘    └─────────────────┘└───────────┘
                                    ▲
                        ┌───────────┴─────────────┐
                        │                         │
             ┌─────────────────────┐ ┌─────────────────────────┐
             │NullPointerException │ │IllegalArgumentException │...
             └─────────────────────┘ └─────────────────────────┘
    从继承关系可知：Throwable是异常体系的根，它继承自Object。Throwable有两个体系：Error和Exception，Error表示严重的错误，程序对此一般无能为力，例如：
    OutOfMemoryError：内存耗尽
    NoClassDefFoundError：无法加载某个Class
    StackOverflowError：栈溢出
    而Exception则是运行时的错误，它可以被捕获并处理。
    某些异常是应用程序逻辑处理的一部分，应该捕获并处理。例如：
    NumberFormatException：数值类型的格式错误
    FileNotFoundException：未找到文件
    SocketException：读取网络失败
    还有一些异常是程序逻辑编写不对造成的，应该修复程序本身。例如：
    NullPointerException：对某个null的对象调用方法或字段
    IndexOutOfBoundsException：数组索引越界
    Exception又分为两大类：
    RuntimeException以及它的子类；
    非RuntimeException（包括IOException、ReflectiveOperationException等等）
    Java规定：
    必须捕获的异常，包括Exception及其子类，但不包括RuntimeException及其子类，这种类型的异常称为Checked Exception。
    不需要捕获的异常，包括Error及其子类，RuntimeException及其子类。
     注意：编译器对RuntimeException及其子类不做强制捕获要求，不是指应用程序本身不应该捕获并处理RuntimeException。是否需要捕获，具体问题具体分析。
##捕获异常
     捕获异常使用try...catch语句，把可能发生异常的代码放到try {...}中，然后使用catch捕获对应的Exception及其子类
     编译器会报错，错误信息类似：unreported exception UnsupportedEncodingException; must be caught or declared to be thrown，并且准确地指出需要捕获的语句是return s.getBytes("GBK");。意思是说，像UnsupportedEncodingException这样的Checked Exception，必须被捕获。
     可见，只要是方法声明的Checked Exception，不在调用层捕获，也必须在更高的调用层捕获。所有未捕获的异常，最终也必须在main()方法中捕获，不会出现漏写try的情况。这是由编译器保证的。main()方法也是最后捕获Exception的机会。
    如果是测试代码，上面的写法就略显麻烦。如果不想写任何try代码，可以直接把main()方法定义为throws Exception
    因为main()方法声明了可能抛出Exception，也就声明了可能抛出所有的Exception，因此在内部就无需捕获了。代价就是一旦发生异常，程序会立刻退出。
    还有一些童鞋喜欢在toGBK()内部“消化”异常：
##小结
    Java使用异常来表示错误，并通过try ... catch捕获异常；
    Java的异常是class，并且从Throwable继承；
    Error是无需捕获的严重错误，Exception是应该捕获的可处理的错误；
    RuntimeException无需强制捕获，非RuntimeException（Checked Exception）需强制捕获，或者用throws声明；
    不推荐捕获了异常但不进行任何处理。
 */
public class JavaException {
    public static void main(String[] args) {
        byte[] bs = toGBK("中文");
        System.out.println(Arrays.toString(bs));
    }

    static byte[] toGBK(String s) {
        try {
            // 用指定编码转换String为byte[]:
            return s.getBytes("GBK");
        } catch (UnsupportedEncodingException e) {
            // 如果系统不支持GBK编码，会捕获到UnsupportedEncodingException:
            System.out.println(e); // 打印异常信息
            return s.getBytes(); // 尝试使用用默认编码
        }
    }

}
